Tensorarray

张量数组操作，支持从张量数组中读取指定索引的张量，或将张量写入到张量数组的指定索引位置。该算子不区分数据类型，适用于所有数据类型。

TensorArrayRead（读取操作）：

从张量数组中读取指定索引的张量，并将其数据复制到输出。

\[\text{output} = \text{tensors}[\text{index}]\]

TensorArrayWrite（写入操作）：

将输入张量的数据复制到张量数组的指定索引位置。

\[\text{tensors}[\text{index}] = \text{input}\]

两个操作都会复制数据，复制大小为 size * type_size 字节。

输入（TensorArrayRead）：

  • tensors - 张量数组（Tensor** 类型），包含多个张量。

  • index - 读取的索引（int 类型），指定从 tensors 数组中读取哪个张量。

  • core_mask - 核掩码（int），仅共享存储版本需要。

输出（TensorArrayRead）：

  • output - 输出张量（Tensor* 类型），包含复制后的数据。输出张量的 size 和 type_size 应与选中的输入张量相同。

输入（TensorArrayWrite）：

  • input - 输入张量（Tensor* 类型），待写入的数据。

  • index - 写入的索引（int 类型），指定写入到 tensors 数组的哪个位置。

  • tensors - 张量数组（Tensor** 类型），目标数组。

  • core_mask - 核掩码（int），仅共享存储版本需要。

输出（TensorArrayWrite）：

  • tensors[index] - 张量数组指定位置的数据会被更新。

支持平台：

FT78NE MT7004

备注

  • 该算子不区分数据类型，适用于所有数据类型

  • 算子会复制数据，输入和输出张量数据独立

  • 调用前需要确保目标内存空间足够大（至少 size * type_size 字节）

  • 读取和写入时，涉及的张量的 size 和 type_size 应匹配

共享存储版本:

TensorArrayRead（读取操作）:

void tensorarrayread_s(Tensor **tensors, int index, Tensor *output, int core_mask)

TensorArrayWrite（写入操作）:

void tensorarraywrite_s(Tensor *input, int index, Tensor **tensors, int core_mask)

C调用示例（TensorArrayRead）：

 1//FT78NE示例
 2#include <stdio.h>
 3#include <tensorarray.h>
 4
 5int main(int argc, char* argv[]) {
 6    // 假设在DDR空间
 7    Tensor tensor0, tensor1, tensor2;
 8    Tensor output;
 9
10    // 初始化张量数组中的张量
11    tensor0.type_size = 4;  // float32
12    tensor0.size = 1000;
13    tensor0.data = (void *)0xA0000000;
14
15    tensor1.type_size = 4;
16    tensor1.size = 1000;
17    tensor1.data = (void *)0xA1000000;
18
19    tensor2.type_size = 4;
20    tensor2.size = 1000;
21    tensor2.data = (void *)0xA2000000;
22
23    // 初始化输出张量
24    output.type_size = 4;
25    output.size = 1000;
26    output.data = (void *)0xB0000000;  // 需要预先分配足够的内存
27
28    // 创建张量数组
29    Tensor* tensors[3] = {&tensor0, &tensor1, &tensor2};
30
31    int index = 1;  // 读取 tensor1
32    int core_mask = 0xff;
33
34    tensorarrayread_s(tensors, index, &output, core_mask);
35
36    // 此时 output.data 包含 tensor1.data 的副本
37
38    return 0;
39}

C调用示例（TensorArrayWrite）：

 1//FT78NE示例
 2#include <stdio.h>
 3#include <tensorarray.h>
 4
 5int main(int argc, char* argv[]) {
 6    // 假设在DDR空间
 7    Tensor input;
 8    Tensor tensor0, tensor1, tensor2;
 9
10    // 初始化输入张量
11    input.type_size = 4;  // float32
12    input.size = 1000;
13    input.data = (void *)0xA0000000;
14
15    // 初始化张量数组中的张量（需要预先分配内存）
16    tensor0.type_size = 4;
17    tensor0.size = 1000;
18    tensor0.data = (void *)0xB0000000;
19
20    tensor1.type_size = 4;
21    tensor1.size = 1000;
22    tensor1.data = (void *)0xB0100000;
23
24    tensor2.type_size = 4;
25    tensor2.size = 1000;
26    tensor2.data = (void *)0xB0200000;
27
28    // 创建张量数组
29    Tensor* tensors[3] = {&tensor0, &tensor1, &tensor2};
30
31    int index = 1;  // 写入到 tensor1 的位置
32    int core_mask = 0xff;
33
34    tensorarraywrite_s(&input, index, tensors, core_mask);
35
36    // 此时 tensors[1]->data 包含 input.data 的副本
37
38    return 0;
39}

私有存储版本:

TensorArrayRead（读取操作）:

void tensorarrayread_p(Tensor **tensors, int index, Tensor *output)

TensorArrayWrite（写入操作）:

void tensorarraywrite_p(Tensor *input, int index, Tensor **tensors)

C调用示例（私有存储版本）：

 1//FT78NE示例
 2#include <stdio.h>
 3#include <tensorarray.h>
 4
 5int main(int argc, char* argv[]) {
 6    // 假设在L2空间
 7    Tensor tensor0, tensor1, tensor2;
 8    Tensor output;
 9
10    tensor0.type_size = 4;  // float32
11    tensor0.size = 1000;
12    tensor0.data = (void *)0x10000000;
13
14    tensor1.type_size = 4;
15    tensor1.size = 1000;
16    tensor1.data = (void *)0x10001000;
17
18    tensor2.type_size = 4;
19    tensor2.size = 1000;
20    tensor2.data = (void *)0x10002000;
21
22    output.type_size = 4;
23    output.size = 1000;
24    output.data = (void *)0x10003000;  // 需要预先分配足够的内存
25
26    Tensor* tensors[3] = {&tensor0, &tensor1, &tensor2};
27
28    int index = 0;  // 读取 tensor0
29
30    tensorarrayread_p(tensors, index, &output);
31
32    return 0;
33}